 (function () {

        if ((typeof (window.cordova) !== 'undefined') || typeof (window.zzcjsbridge) !== 'undefined') {
               return;
        }
        window.cordova = null;
        var PLATFORM_VERSION_BUILD_LABEL = '3.8.0';
        var require, define;

        (function () {
               var modules = {},
                      // Stack of moduleIds currently being built.
                      requireStack = [],
                      // Map of module ID -> index into requireStack of modules currently being built.
                      inProgressModules = {},
                      SEPARATOR = ".";

               function build(module) {
                      var factory = module.factory,
                             localRequire = function (id) {
                                    var resultantId = id;
                                    //Its a relative path, so lop off the last portion and add the id (minus "./")
                                    if (id.charAt(0) === ".") {
                                           resultantId = module.id.slice(0, module.id.lastIndexOf(SEPARATOR)) + SEPARATOR + id.slice(2);
                                    }
                                    return require(resultantId);
                             };
                      module.exports = {};
                      delete module.factory;
                      factory(localRequire, module.exports, module);
                      return module.exports;
               }

               require = function (id) {
                      if (!modules[id]) {
                             throw "module " + id + " not found";
                      } else if (id in inProgressModules) {
                             var cycle = requireStack.slice(inProgressModules[id]).join('->') + '->' + id;
                             throw "Cycle in require graph: " + cycle;
                      }
                      if (modules[id].factory) {
                             try {
                                    inProgressModules[id] = requireStack.length;
                                    requireStack.push(id);
                                    return build(modules[id]);
                             } finally {
                                    delete inProgressModules[id];
                                    requireStack.pop();
                             }
                      }
                      return modules[id].exports;
               };

               define = function (id, factory) {
                      if (modules[id]) {
                             throw "module " + id + " already defined";
                      }

                      modules[id] = {
                             id: id,
                             factory: factory
                      };
               };

               define.remove = function (id) {
                      delete modules[id];
               };

               define.moduleMap = modules;
        })();

        //Export for use in node
        if (typeof module === "object" && typeof require === "function") {
               module.exports.require = require;
               module.exports.define = define;
        }

        // file: src/cordova.js
        define("cordova",
               function (require, exports, module) {

                      var channel = require('cordova/channel');
                      var platform = require('cordova/platform');
                      var m_document_addEventListener = document.addEventListener;
                      var m_document_removeEventListener = document.removeEventListener;
                      var m_window_addEventListener = window.addEventListener;
                      var m_window_removeEventListener = window.removeEventListener;
                      var documentEventHandlers = {},
                             windowEventHandlers = {};

                      document.addEventListener = function (evt, handler, capture) {
                             var e = evt.toLowerCase();
                             if (typeof documentEventHandlers[e] != 'undefined') {
                                    documentEventHandlers[e].subscribe(handler);
                             } else {
                                    m_document_addEventListener.call(document, evt, handler, capture);
                             }
                      };

                      window.addEventListener = function (evt, handler, capture) {
                             var e = evt.toLowerCase();
                             if (typeof windowEventHandlers[e] != 'undefined') {
                                    windowEventHandlers[e].subscribe(handler);
                             } else {
                                    m_window_addEventListener.call(window, evt, handler, capture);
                             }
                      };

                      document.removeEventListener = function (evt, handler, capture) {
                             var e = evt.toLowerCase();
                             // If unsubscribing from an event that is handled by a plugin
                             if (typeof documentEventHandlers[e] != "undefined") {
                                    documentEventHandlers[e].unsubscribe(handler);
                             } else {
                                    m_document_removeEventListener.call(document, evt, handler, capture);
                             }
                      };

                      window.removeEventListener = function (evt, handler, capture) {
                             var e = evt.toLowerCase();
                             // If unsubscribing from an event that is handled by a plugin
                             if (typeof windowEventHandlers[e] != "undefined") {
                                    windowEventHandlers[e].unsubscribe(handler);
                             } else {
                                    m_window_removeEventListener.call(window, evt, handler, capture);
                             }
                      };

                      function createEvent(type, data) {
                             var event = document.createEvent('Events');
                             event.initEvent(type, false, false);
                             if (data) {
                                    for (var i in data) {
                                           if (data.hasOwnProperty(i)) {
                                                  event[i] = data[i];
                                           }
                                    }
                             }
                             return event;
                      }

                      var cordova = {
                             define: define,
                             require: require,
                             version: PLATFORM_VERSION_BUILD_LABEL,
                             platformVersion: PLATFORM_VERSION_BUILD_LABEL,
                             platformId: platform.id,
                             addWindowEventHandler: function (event) {
                                    return (windowEventHandlers[event] = channel.create(event));
                             },
                             addStickyDocumentEventHandler: function (event) {
                                    return (documentEventHandlers[event] = channel.createSticky(event));
                             },
                             addDocumentEventHandler: function (event) {
                                    return (documentEventHandlers[event] = channel.create(event));
                             },
                             removeWindowEventHandler: function (event) {
                                    delete windowEventHandlers[event];
                             },
                             removeDocumentEventHandler: function (event) {
                                    delete documentEventHandlers[event];
                             },
                             getOriginalHandlers: function () {
                                    return {
                                           'document': {
                                                  'addEventListener': m_document_addEventListener,
                                                  'removeEventListener': m_document_removeEventListener
                                           },
                                           'window': {
                                                  'addEventListener': m_window_addEventListener,
                                                  'removeEventListener': m_window_removeEventListener
                                           }
                                    };
                             },
                             fireDocumentEvent: function (type, data, bNoDetach) {
                                    var evt = createEvent(type, data);
                                    if (typeof documentEventHandlers[type] != 'undefined') {
                                           if (bNoDetach) {
                                                  documentEventHandlers[type].fire(evt);
                                           } else {
                                                  setTimeout(function () {
                                                                // Fire deviceready on listeners that were registered before cordova.js was loaded.
                                                                if (type == 'deviceready') {
                                                                       document.dispatchEvent(evt);
                                                                }
                                                                documentEventHandlers[type].fire(evt);
                                                         },
                                                         0);
                                           }
                                    } else {
                                           document.dispatchEvent(evt);
                                    }
                             },
                             fireWindowEvent: function (type, data) {
                                    var evt = createEvent(type, data);
                                    if (typeof windowEventHandlers[type] != 'undefined') {
                                           setTimeout(function () {
                                                         windowEventHandlers[type].fire(evt);
                                                  },
                                                  0);
                                    } else {
                                           window.dispatchEvent(evt);
                                    }
                             },
                             callbackId: Math.floor(Math.random() * 2000000000),
                             callbacks: {},
                             callbackStatus: {
                                    NO_RESULT: 0,
                                    OK: 1,
                                    CLASS_NOT_FOUND_EXCEPTION: 2,
                                    ILLEGAL_ACCESS_EXCEPTION: 3,
                                    INSTANTIATION_EXCEPTION: 4,
                                    MALFORMED_URL_EXCEPTION: 5,
                                    IO_EXCEPTION: 6,
                                    INVALID_ACTION: 7,
                                    JSON_EXCEPTION: 8,
                                    ERROR: 9,
                                    CUSTOM: 10
                             },
                             callbackSuccess: function (callbackId, args) {
                                    cordova.callbackFromNative(callbackId, true, args.status, [args.message], args.keepCallback);
                             },
                             callbackError: function (callbackId, args) {
                                    cordova.callbackFromNative(callbackId, false, args.status, [args.message], args.keepCallback);
                             },
                             callbackFromNative: function (callbackId, isSuccess, status, args, keepCallback) {
                                    try {
                                           var callback = cordova.callbacks[callbackId];
                                           if (callback) {
                                                  if (isSuccess && status == cordova.callbackStatus.OK) {
                                                         callback.success && callback.success.apply(null, args);
                                                  } else if (!isSuccess && status == cordova.callbackStatus.CUSTOM) {
                                                         callback.fail && callback.fail.apply(null, args);
                                                  }
                                                  if (!keepCallback) {
                                                         delete cordova.callbacks[callbackId];
                                                  }
                                           }
                                    } catch (err) {
                                           var msg = "Error in " + (isSuccess ? "Success" : "Error") + " callbackId: " + callbackId + " : " + err;
                                           console && console.log && console.log(msg);
                                           cordova.fireWindowEvent("cordovacallbackerror", {
                                                  'message': msg
                                           });
                                           throw err;
                                    }
                             },
                             addConstructor: function (func) {
                                    channel.onCordovaReady.subscribe(function () {
                                           try {
                                                  func();
                                           } catch (e) {
                                                  console.log("Failed to run constructor: " + e);
                                           }
                                    });
                             }
                      };

                      module.exports = cordova;

               });

        // file: src/common/argscheck.js
        define("cordova/argscheck",
               function (require, exports, module) {

                      var exec = require('cordova/exec');
                      var utils = require('cordova/utils');

                      var moduleExports = module.exports;

                      var typeMap = {
                             'A': 'Array',
                             'D': 'Date',
                             'N': 'Number',
                             'S': 'String',
                             'F': 'Function',
                             'O': 'Object'
                      };

                      function extractParamName(callee, argIndex) {
                             return (/.*?\((.*?)\)/).exec(callee)[1].split(', ')[argIndex];
                      }

                      function checkArgs(spec, functionName, args, opt_callee) {
                             if (!moduleExports.enableChecks) {
                                    return;
                             }
                             var errMsg = null;
                             var typeName;
                             for (var i = 0; i < spec.length; ++i) {
                                    var c = spec.charAt(i),
                                           cUpper = c.toUpperCase(),
                                           arg = args[i];
                                    // Asterix means allow anything.
                                    if (c == '*') {
                                           continue;
                                    }
                                    typeName = utils.typeName(arg);
                                    if ((arg === null || arg === undefined) && c == cUpper) {
                                           continue;
                                    }
                                    if (typeName != typeMap[cUpper]) {
                                           errMsg = 'Expected ' + typeMap[cUpper];
                                           break;
                                    }
                             }
                             if (errMsg) {
                                    errMsg += ', but got ' + typeName + '.';
                                    errMsg = 'Wrong type for parameter "' + extractParamName(opt_callee || args.callee, i) + '" of ' + functionName + ': ' + errMsg;
                                    // Don't log when running unit tests.
                                    if (typeof jasmine == 'undefined') {
                                           console.error(errMsg);
                                    }
                                    throw TypeError(errMsg);
                             }
                      }

                      function getValue(value, defaultValue) {
                             return value === undefined ? defaultValue : value;
                      }

                      moduleExports.checkArgs = checkArgs;
                      moduleExports.getValue = getValue;
                      moduleExports.enableChecks = true;

               });

        // file: src/common/base64.js
        define("cordova/base64",
               function (require, exports, module) {

                      var base64 = exports;

                      base64.fromArrayBuffer = function (arrayBuffer) {
                             var array = new Uint8Array(arrayBuffer);
                             return uint8ToBase64(array);
                      };

                      base64.toArrayBuffer = function (str) {
                             var decodedStr = typeof atob != 'undefined' ? atob(str) : new Buffer(str, 'base64').toString('binary');
                             var arrayBuffer = new ArrayBuffer(decodedStr.length);
                             var array = new Uint8Array(arrayBuffer);
                             for (var i = 0,
                                           len = decodedStr.length; i < len; i++) {
                                    array[i] = decodedStr.charCodeAt(i);
                             }
                             return arrayBuffer;
                      };

                      var b64_6bit = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
                      var b64_12bit;

                      var b64_12bitTable = function () {
                             b64_12bit = [];
                             for (var i = 0; i < 64; i++) {
                                    for (var j = 0; j < 64; j++) {
                                           b64_12bit[i * 64 + j] = b64_6bit[i] + b64_6bit[j];
                                    }
                             }
                             b64_12bitTable = function () {
                                    return b64_12bit;
                             };
                             return b64_12bit;
                      };

                      function uint8ToBase64(rawData) {
                             var numBytes = rawData.byteLength;
                             var output = "";
                             var segment;
                             var table = b64_12bitTable();
                             for (var i = 0; i < numBytes - 2; i += 3) {
                                    segment = (rawData[i] << 16) + (rawData[i + 1] << 8) + rawData[i + 2];
                                    output += table[segment >> 12];
                                    output += table[segment & 0xfff];
                             }
                             if (numBytes - i == 2) {
                                    segment = (rawData[i] << 16) + (rawData[i + 1] << 8);
                                    output += table[segment >> 12];
                                    output += b64_6bit[(segment & 0xfff) >> 6];
                                    output += '=';
                             } else if (numBytes - i == 1) {
                                    segment = (rawData[i] << 16);
                                    output += table[segment >> 12];
                                    output += '==';
                             }
                             return output;
                      }

               });

        // file: src/common/builder.js
        define("cordova/builder",
               function (require, exports, module) {

                      var utils = require('cordova/utils');

                      function each(objects, func, context) {
                             for (var prop in objects) {
                                    if (objects.hasOwnProperty(prop)) {
                                           func.apply(context, [objects[prop], prop]);
                                    }
                             }
                      }

                      function clobber(obj, key, value) {
                             exports.replaceHookForTesting(obj, key);
                             var needsProperty = false;
                             try {
                                    obj[key] = value;
                             } catch (e) {
                                    needsProperty = true;
                             }
                             // Getters can only be overridden by getters.
                             if (needsProperty || obj[key] !== value) {
                                    utils.defineGetter(obj, key,
                                           function () {
                                                  return value;
                                           });
                             }
                      }

                      function assignOrWrapInDeprecateGetter(obj, key, value, message) {
                             if (message) {
                                    utils.defineGetter(obj, key,
                                           function () {
                                                  console.log(message);
                                                  delete obj[key];
                                                  clobber(obj, key, value);
                                                  return value;
                                           });
                             } else {
                                    clobber(obj, key, value);
                             }
                      }

                      function include(parent, objects, clobber, merge) {
                             each(objects,
                                    function (obj, key) {
                                           try {
                                                  var result = obj.path ? require(obj.path) : {};

                                                  if (clobber) {
                                                         // Clobber if it doesn't exist.
                                                         if (typeof parent[key] === 'undefined') {
                                                                assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
                                                         } else if (typeof obj.path !== 'undefined') {
                                                                // If merging, merge properties onto parent, otherwise, clobber.
                                                                if (merge) {
                                                                       recursiveMerge(parent[key], result);
                                                                } else {
                                                                       assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
                                                                }
                                                         }
                                                         result = parent[key];
                                                  } else {
                                                         // Overwrite if not currently defined.
                                                         if (typeof parent[key] == 'undefined') {
                                                                assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
                                                         } else {
                                                                // Set result to what already exists, so we can build children into it if they exist.
                                                                result = parent[key];
                                                         }
                                                  }

                                                  if (obj.children) {
                                                         include(result, obj.children, clobber, merge);
                                                  }
                                           } catch (e) {
                                                  utils.alert('Exception building Cordova JS globals: ' + e + ' for key "' + key + '"');
                                           }
                                    });
                      }

                      function recursiveMerge(target, src) {
                             for (var prop in src) {
                                    if (src.hasOwnProperty(prop)) {
                                           if (target.prototype && target.prototype.constructor === target) {
                                                  // If the target object is a constructor override off prototype.
                                                  clobber(target.prototype, prop, src[prop]);
                                           } else {
                                                  if (typeof src[prop] === 'object' && typeof target[prop] === 'object') {
                                                         recursiveMerge(target[prop], src[prop]);
                                                  } else {
                                                         clobber(target, prop, src[prop]);
                                                  }
                                           }
                                    }
                             }
                      }

                      exports.buildIntoButDoNotClobber = function (objects, target) {
                             include(target, objects, false, false);
                      };
                      exports.buildIntoAndClobber = function (objects, target) {
                             include(target, objects, true, false);
                      };
                      exports.buildIntoAndMerge = function (objects, target) {
                             include(target, objects, true, true);
                      };
                      exports.recursiveMerge = recursiveMerge;
                      exports.assignOrWrapInDeprecateGetter = assignOrWrapInDeprecateGetter;
                      exports.replaceHookForTesting = function () {};

               });

        // file: src/common/channel.js
        define("cordova/channel",
               function (require, exports, module) {

                      var utils = require('cordova/utils'),
                             nextGuid = 1;
                      var Channel = function (type, sticky) {
                                    this.type = type;
                                    // Map of guid -> function.
                                    this.handlers = {};
                                    // 0 = Non-sticky, 1 = Sticky non-fired, 2 = Sticky fired.
                                    this.state = sticky ? 1 : 0;
                                    // Used in sticky mode to remember args passed to fire().
                                    this.fireArgs = null;
                                    // Used by onHasSubscribersChange to know if there are any listeners.
                                    this.numHandlers = 0;
                                    // Function that is called when the first listener is subscribed, or when
                                    // the last listener is unsubscribed.
                                    this.onHasSubscribersChange = null;
                             },
                             channel = {

                                    join: function (h, c) {
                                           var len = c.length,
                                                  i = len,
                                                  f = function () {
                                                         if (!(--i)) h();
                                                  };
                                           for (var j = 0; j < len; j++) {
                                                  if (c[j].state === 0) {
                                                         throw Error('Can only use join with sticky channels.');
                                                  }
                                                  c[j].subscribe(f);
                                           }
                                           if (!len) h();
                                    },
                                    create: function (type) {
                                           return channel[type] = new Channel(type, false);
                                    },
                                    createSticky: function (type) {
                                           return channel[type] = new Channel(type, true);
                                    },

                                    deviceReadyChannelsArray: [],
                                    deviceReadyChannelsMap: {},
                                    waitForInitialization: function (feature) {
                                           if (feature) {
                                                  var c = channel[feature] || this.createSticky(feature);
                                                  this.deviceReadyChannelsMap[feature] = c;
                                                  this.deviceReadyChannelsArray.push(c);
                                           }
                                    },
                                    initializationComplete: function (feature) {
                                           var c = this.deviceReadyChannelsMap[feature];
                                           if (c) {
                                                  c.fire();
                                           }
                                    }
                             };

                      function forceFunction(f) {
                             if (typeof f != 'function') throw "Function required as first argument!";
                      }

                      Channel.prototype.subscribe = function (f, c) {
                             // need a function to call
                             forceFunction(f);
                             if (this.state == 2) {
                                    f.apply(c || this, this.fireArgs);
                                    return;
                             }

                             var func = f,
                                    guid = f.observer_guid;
                             if (typeof c == "object") {
                                    func = utils.close(c, f);
                             }

                             if (!guid) {
                                    // first time any channel has seen this subscriber
                                    guid = '' + nextGuid++;
                             }
                             func.observer_guid = guid;
                             f.observer_guid = guid;

                             // Don't add the same handler more than once.
                             if (!this.handlers[guid]) {
                                    this.handlers[guid] = func;
                                    this.numHandlers++;
                                    if (this.numHandlers == 1) {
                                           this.onHasSubscribersChange && this.onHasSubscribersChange();
                                    }
                             }
                      };
                      Channel.prototype.unsubscribe = function (f) {
                             // need a function to unsubscribe
                             forceFunction(f);

                             var guid = f.observer_guid,
                                    handler = this.handlers[guid];
                             if (handler) {
                                    delete this.handlers[guid];
                                    this.numHandlers--;
                                    if (this.numHandlers === 0) {
                                           this.onHasSubscribersChange && this.onHasSubscribersChange();
                                    }
                             }
                      };
                      Channel.prototype.fire = function (e) {
                             var fail = false,
                                    fireArgs = Array.prototype.slice.call(arguments);
                             // Apply stickiness.
                             if (this.state == 1) {
                                    this.state = 2;
                                    this.fireArgs = fireArgs;
                             }
                             if (this.numHandlers) {
                                    // Copy the values first so that it is safe to modify it from within
                                    // callbacks.
                                    var toCall = [];
                                    for (var item in this.handlers) {
                                           toCall.push(this.handlers[item]);
                                    }
                                    for (var i = 0; i < toCall.length; ++i) {
                                           toCall[i].apply(this, fireArgs);
                                    }
                                    if (this.state == 2 && this.numHandlers) {
                                           this.numHandlers = 0;
                                           this.handlers = {};
                                           this.onHasSubscribersChange && this.onHasSubscribersChange();
                                    }
                             }
                      };

                      channel.createSticky('onDOMContentLoaded');
                      channel.createSticky('onNativeReady');
                      channel.createSticky('onCordovaReady');
                      channel.createSticky('onPluginsReady');
                      channel.createSticky('onDeviceReady');
                      channel.create('onResume');
                      channel.create('onPause');
                      channel.waitForInitialization('onCordovaReady');
                      channel.waitForInitialization('onDOMContentLoaded');

                      module.exports = channel;

               });

        // file: src/ios/exec.js
        define("cordova/exec",
               function (require, exports, module) {
                      var cordova = require('cordova'),
                             channel = require('cordova/channel'),
                             utils = require('cordova/utils'),
                             base64 = require('cordova/base64'),

                             jsToNativeModes = {
                                    IFRAME_NAV: 0,
                                    // Default. Uses a new iframe for each poke.
                                    // XHR bridge appears to be flaky sometimes: CB-3900, CB-3359, CB-5457, CB-4970, CB-4998, CB-5134
                                    XHR_NO_PAYLOAD: 1,
                                    // About the same speed as IFRAME_NAV. Performance not about the same as IFRAME_NAV, but more variable.
                                    XHR_WITH_PAYLOAD: 2,
                                    // Flakey, and not as performant
                                    XHR_OPTIONAL_PAYLOAD: 3,
                                    // Flakey, and not as performant
                                    IFRAME_HASH_NO_PAYLOAD: 4,
                                    // Not fully baked. A bit faster than IFRAME_NAV, but risks jank since poke happens synchronously.
                                    IFRAME_HASH_WITH_PAYLOAD: 5,
                                    // Slower than no payload. Maybe since it has to be URI encoded / decoded.
                                    WK_WEBVIEW_BINDING: 6 // Only way that works for WKWebView :)
                             },
                             bridgeMode,
                             execIframe,
                             execHashIframe,
                             hashToggle = 1,
                             execXhr,
                             requestCount = 0,
                             vcHeaderValue = null,
                             commandQueue = [],
                             // Contains pending JS->Native messages.
                             isInContextOfEvalJs = 0,
                             failSafeTimerId = 0;

                      function shouldBundleCommandJson() {
                             if (bridgeMode === jsToNativeModes.XHR_WITH_PAYLOAD) {
                                    return true;
                             }
                             if (bridgeMode === jsToNativeModes.XHR_OPTIONAL_PAYLOAD) {
                                    var payloadLength = 0;
                                    for (var i = 0; i < commandQueue.length; ++i) {
                                           payloadLength += commandQueue[i].length;
                                    }
                                    // The value here was determined using the benchmark within CordovaLibApp on an iPad 3.
                                    return payloadLength < 4500;
                             }
                             return false;
                      }

                      function massageArgsJsToNative(args) {
                             if (!args || utils.typeName(args) != 'Array') {
                                    return args;
                             }
                             var ret = [];
                             args.forEach(function (arg, i) {
                                    if (utils.typeName(arg) == 'ArrayBuffer') {
                                           ret.push({
                                                  'CDVType': 'ArrayBuffer',
                                                  'data': base64.fromArrayBuffer(arg)
                                           });
                                    } else {
                                           ret.push(arg);
                                    }
                             });
                             return ret;
                      }

                      function massageMessageNativeToJs(message) {
                             if (message.CDVType == 'ArrayBuffer') {
                                    var stringToArrayBuffer = function (str) {
                                           var ret = new Uint8Array(str.length);
                                           for (var i = 0; i < str.length; i++) {
                                                  ret[i] = str.charCodeAt(i);
                                           }
                                           return ret.buffer;
                                    };
                                    var base64ToArrayBuffer = function (b64) {
                                           return stringToArrayBuffer(atob(b64));
                                    };
                                    message = base64ToArrayBuffer(message.data);
                             }
                             return message;
                      }

                      function convertMessageToArgsNativeToJs(message) {
                             var args = [];
                             if (!message || !message.hasOwnProperty('CDVType')) {
                                    args.push(message);
                             } else if (message.CDVType == 'MultiPart') {
                                    message.messages.forEach(function (e) {
                                           args.push(massageMessageNativeToJs(e));
                                    });
                             } else {
                                    args.push(massageMessageNativeToJs(message));
                             }
                             return args;
                      }

                      function iOSExec() {
                             if (bridgeMode === undefined) {
                                    bridgeMode = jsToNativeModes.IFRAME_NAV;
                             }

                             if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.cordova && window.webkit.messageHandlers.cordova.postMessage) {
                                    bridgeMode = jsToNativeModes.WK_WEBVIEW_BINDING;
                             }

                             var successCallback, failCallback, service, action, actionArgs, splitCommand;
                             var callbackId = null;
                             if (typeof arguments[0] !== "string") {
                                    // FORMAT ONE
                                    successCallback = arguments[0];
                                    failCallback = arguments[1];
                                    service = arguments[2];
                                    action = arguments[3];
                                    actionArgs = arguments[4];
                                    callbackId = 'INVALID';
                             } else {
                                    // FORMAT TWO, REMOVED
                                    try {
                                           splitCommand = arguments[0].split(".");
                                           action = splitCommand.pop();
                                           service = splitCommand.join(".");
                                           actionArgs = Array.prototype.splice.call(arguments, 1);

                                           console.log('The old format of this exec call has been removed (deprecated since 2.1). Change to: ' + "cordova.exec(null, null, \"" + service + "\", \"" + action + "\"," + JSON.stringify(actionArgs) + ");");
                                           return;
                                    } catch (e) {}
                             }

                             // If actionArgs is not provided, default to an empty array
                             actionArgs = actionArgs || [];
                             if (successCallback || failCallback) {
                                    callbackId = service + cordova.callbackId++;
                                    cordova.callbacks[callbackId] = {
                                           success: successCallback,
                                           fail: failCallback
                                    };
                             }

                             actionArgs = massageArgsJsToNative(actionArgs);

                             var command = [callbackId, service, action, actionArgs];
                             commandQueue.push(JSON.stringify(command));

                             if (bridgeMode === jsToNativeModes.WK_WEBVIEW_BINDING) {
                                    window.webkit.messageHandlers.cordova.postMessage(command);
                             } else {

                                    if (!isInContextOfEvalJs && commandQueue.length == 1) {
                                           pokeNative();
                                    }
                             }
                      }

                      function pokeNative() {
                             switch (bridgeMode) {
                                    case jsToNativeModes.XHR_NO_PAYLOAD:
                                    case jsToNativeModes.XHR_WITH_PAYLOAD:
                                    case jsToNativeModes.XHR_OPTIONAL_PAYLOAD:
                                           pokeNativeViaXhr();
                                           break;
                                    default:
                                           // iframe-based.
                                           pokeNativeViaIframe();
                             }
                      }

                      function pokeNativeViaXhr() {
                             if (execXhr && execXhr.readyState != 4) {
                                    execXhr = null;
                             }
                             execXhr = execXhr || new XMLHttpRequest();
                             execXhr.open('HEAD', "/!gap_exec?" + (+new Date()), true);
                             if (!vcHeaderValue) {
                                    vcHeaderValue = /.*\((.*)\)$/.exec(navigator.userAgent)[1];
                             }
                             execXhr.setRequestHeader('vc', vcHeaderValue);
                             execXhr.setRequestHeader('rc', ++requestCount);
                             if (shouldBundleCommandJson()) {
                                    execXhr.setRequestHeader('cmds', iOSExec.nativeFetchMessages());
                             }
                             execXhr.send(null);
                      }

                      function pokeNativeViaIframe() {
                             // CB-5488 - Don't attempt to create iframe before document.body is available.
                             if (!document.body) {
                                    setTimeout(pokeNativeViaIframe);
                                    return;
                             }
                             if (bridgeMode === jsToNativeModes.IFRAME_HASH_NO_PAYLOAD || bridgeMode === jsToNativeModes.IFRAME_HASH_WITH_PAYLOAD) {
                                    // TODO: This bridge mode doesn't properly support being removed from the DOM (CB-7735)
                                    if (!execHashIframe) {
                                           execHashIframe = document.createElement('iframe');
                                           execHashIframe.style.display = 'none';
                                           document.body.appendChild(execHashIframe);
                                           // Hash changes don't work on about:blank, so switch it to file:///.
                                           execHashIframe.contentWindow.history.replaceState(null, null, 'file:///#');
                                    }
                                    // The delegate method is called only when the hash changes, so toggle it back and forth.
                                    hashToggle = hashToggle ^ 3;
                                    var hashValue = '%0' + hashToggle;
                                    if (bridgeMode === jsToNativeModes.IFRAME_HASH_WITH_PAYLOAD) {
                                           hashValue += iOSExec.nativeFetchMessages();
                                    }
                                    execHashIframe.contentWindow.location.hash = hashValue;
                             } else {
                                    // Check if they've removed it from the DOM, and put it back if so.
                                    if (execIframe && execIframe.contentWindow) {
                                           execIframe.contentWindow.location = 'gap://ready';
                                    } else {
                                           execIframe = document.createElement('iframe');
                                           execIframe.style.display = 'none';
                                           execIframe.src = 'gap://ready';
                                           document.body.appendChild(execIframe);
                                    }
                                    failSafeTimerId = setTimeout(function () {
                                                  if (commandQueue.length) {
                                                         pokeNative();
                                                  }
                                           },
                                           50); // Making this > 0 improves performance (marginally) in the normal case (where it doesn't fire).
                             }
                      }

                      iOSExec.jsToNativeModes = jsToNativeModes;

                      iOSExec.setJsToNativeBridgeMode = function (mode) {
                             if (execIframe) {
                                    if (execIframe.parentNode) {
                                           execIframe.parentNode.removeChild(execIframe);
                                    }
                                    execIframe = null;
                             }
                             bridgeMode = mode;
                      };

                      iOSExec.nativeFetchMessages = function () {
                             // Stop listing for window detatch once native side confirms poke.
                             if (failSafeTimerId) {
                                    clearTimeout(failSafeTimerId);
                                    failSafeTimerId = 0;
                             }
                             // Each entry in commandQueue is a JSON string already.
                             if (!commandQueue.length) {
                                    return '';
                             }
                             var json = '[' + commandQueue.join(',') + ']';
                             commandQueue.length = 0;
                             return json;
                      };
                     iOSExec.nativeCallback = function (callbackId, status, message, keepCallback) {
                            //  return iOSExec.nativeEvalAndFetch(function () {
                            //         var success = status === 0 || status === 1;
                            //         var args = convertMessageToArgsNativeToJs(message);
                            //         cordova.callbackFromNative(callbackId, success, status, args, keepCallback);
                            //  });
                            var success = status === 0 || status === 1;
                            var args = convertMessageToArgsNativeToJs(message);
                            cordova.callbackFromNative(callbackId, success, status, args, keepCallback);
                     };

                      iOSExec.nativeEvalAndFetch = function (func) {
                             // This shouldn't be nested, but better to be safe.
                            //  isInContextOfEvalJs++;
                            //  try {
                            //         func();
                            //         return iOSExec.nativeFetchMessages();
                            //  } finally {
                            //         isInContextOfEvalJs--;
                            //  }
                            try {
                                   func();
                            } catch (e) {
                                   console.log(e);
                            }
                      };

                      module.exports = iOSExec;

               });

        define("cordova/exec/proxy",
               function (require, exports, module) {

                      var CommandProxyMap = {};

                      module.exports = {
                             add: function (id, proxyObj) {
                                    console.log("adding proxy for " + id);
                                    CommandProxyMap[id] = proxyObj;
                                    return proxyObj;
                             },

                             remove: function (id) {
                                    var proxy = CommandProxyMap[id];
                                    delete CommandProxyMap[id];
                                    CommandProxyMap[id] = null;
                                    return proxy;
                             },

                             get: function (service, action) {
                                    return (CommandProxyMap[service] ? CommandProxyMap[service][action] : null);
                             }
                      };
               });
        define("cordova/init",
               function (require, exports, module) {

                      var channel = require('cordova/channel');
                      var cordova = require('cordova');
                      var modulemapper = require('cordova/modulemapper');
                      var platform = require('cordova/platform');
                      var pluginloader = require('cordova/pluginloader');
                      var utils = require('cordova/utils');

                      var platformInitChannelsArray = [channel.onNativeReady, channel.onPluginsReady];

                      function logUnfiredChannels(arr) {
                             for (var i = 0; i < arr.length; ++i) {
                                    if (arr[i].state != 2) {
                                           console.log('Channel not fired: ' + arr[i].type);
                                    }
                             }
                      }

                      window.setTimeout(function () {
                                    if (channel.onDeviceReady.state != 2) {
                                           console.log('deviceready has not fired after 5 seconds.');
                                           logUnfiredChannels(platformInitChannelsArray);
                                           logUnfiredChannels(channel.deviceReadyChannelsArray);
                                    }
                             },
                             5000);

                      function replaceNavigator(origNavigator) {
                             var CordovaNavigator = function () {};
                             CordovaNavigator.prototype = origNavigator;
                             var newNavigator = new CordovaNavigator();
                             if (CordovaNavigator.bind) {
                                    for (var key in origNavigator) {
                                           if (typeof origNavigator[key] == 'function') {
                                                  newNavigator[key] = origNavigator[key].bind(origNavigator);
                                           } else {
                                                  (function (k) {
                                                         utils.defineGetterSetter(newNavigator, key,
                                                                function () {
                                                                       return origNavigator[k];
                                                                });
                                                  })(key);
                                           }
                                    }
                             }
                             return newNavigator;
                      }

                      if (window.navigator) {
                             window.navigator = replaceNavigator(window.navigator);
                      }

                      if (!window.console) {
                             window.console = {
                                    log: function () {}
                             };
                      }
                      if (!window.console.warn) {
                             window.console.warn = function (msg) {
                                    this.log("warn: " + msg);
                             };
                      }

                      // Register pause, resume and deviceready channels as events on document.
                      channel.onPause = cordova.addDocumentEventHandler('pause');
                      channel.onResume = cordova.addDocumentEventHandler('resume');
                      channel.onDeviceReady = cordova.addStickyDocumentEventHandler('deviceready');

                      // Listen for DOMContentLoaded and notify our channel subscribers.
                      if (document.readyState == 'complete' || document.readyState == 'interactive') {
                             channel.onDOMContentLoaded.fire();
                      } else {
                             document.addEventListener('DOMContentLoaded',
                                    function () {
                                           channel.onDOMContentLoaded.fire();
                                    },
                                    false);
                      }
                      if (window._nativeReady) {
                             channel.onNativeReady.fire();
                      }

                      modulemapper.clobbers('cordova', 'cordova');
                      modulemapper.clobbers('cordova/exec', 'cordova.exec');
                      modulemapper.clobbers('cordova/exec', 'Cordova.exec');

                      var jsName = 'zzcjsbridge';
                      //config
                      modulemapper.clobbers('cordova', jsName);
                      //TODO: 接口声明
                      modulemapper.clobbers('jsbridge/base_backToPreviousPage', jsName + '.base_backToPreviousPage');
                      modulemapper.clobbers('jsbridge/base_backToPreviousPage', jsName + '.BackToPreviousPage');
                      modulemapper.clobbers('jsbridge/base_backToPreviousPage', jsName + '.backtopreviouspage');
                      modulemapper.clobbers('jsbridge/base_goBackPage', jsName + '.base_goBackPage');
                      modulemapper.clobbers('jsbridge/base_destroyPage', jsName + '.base_destroyPage');

                      modulemapper.clobbers('jsbridge/jumpToTopPage', jsName + '.base_backToHome');
                      modulemapper.clobbers('jsbridge/jumpToTopPage', jsName + '.Backtohome');
                      modulemapper.clobbers('jsbridge/jumpToTopPage', jsName + '.backtohome');

                      modulemapper.clobbers('jsbridge/controlLeftPanGesture', jsName + '.base_controlLeftPanGesture');
                      modulemapper.clobbers('jsbridge/showNavBarMoreMenu', jsName + '.base_navbarRightPopover');
                      modulemapper.clobbers('jsbridge/share', jsName + '.Share');
                      modulemapper.clobbers('jsbridge/share', jsName + '.share');
                      modulemapper.clobbers('jsbridge/share', jsName + '.base_share');
                      modulemapper.clobbers('jsbridge/showActionSheet', jsName + '.base_showNativeActionSheet');
                      modulemapper.clobbers('jsbridge/showActionSheet', jsName + '.Base_showNativeActionSheet');

                      modulemapper.clobbers('jsbridge/setTopNavBarFadeIn', jsName + '.base_setTopNavbarFadeIn');
                      modulemapper.clobbers('jsbridge/setTopNavBarFadeIn', jsName + '.base_SetStatusBarState');
                      modulemapper.clobbers('jsbridge/setTopNavBarFadeIn', jsName + '.base_SetSearchBarState');
                      modulemapper.clobbers('jsbridge/setTopNavBarFadeIn', jsName + '.Base_SetSearchBarState');

                      modulemapper.clobbers('jsbridge/navBarRightButtons', jsName + '.base_navbarRightButtons');
                      modulemapper.clobbers('jsbridge/navBarLeftButtons', jsName + '.base_navbarLeftButtons');
                      modulemapper.clobbers('jsbridge/customNavbarRightButton', jsName + '.base_customNavbarRightButton');
                      modulemapper.clobbers('jsbridge/customNavbarLeftButton', jsName + '.base_customNavbarLeftButton');
                      modulemapper.clobbers('jsbridge/setTopBackBtnState', jsName + '.base_setTopBackBtnState');
                      modulemapper.clobbers('jsbridge/setTitle', jsName + '.base_webviewTitle');
                      modulemapper.clobbers('jsbridge/setTitle', jsName + '.WebviewTitle');
                      modulemapper.clobbers('jsbridge/setTitle', jsName + '.webviewtitle');

               
                      modulemapper.clobbers('jsbridge/nativePay', jsName + '.nativePay');
//                      modulemapper.clobbers('jsbridge/startAlipay', jsName + '.alipay');
                      modulemapper.clobbers('jsbridge/alipayAppIsInstalled', jsName + '.alipayappcheck');
                      modulemapper.clobbers('jsbridge/com_checkPayClient', jsName + '.com_checkPayClient');
//                      modulemapper.clobbers('jsbridge/startWechatPay', jsName + '.wxpay');
                      modulemapper.clobbers('jsbridge/wechatAppIsInstalled', jsName + '.wxpayappcheck');
                      modulemapper.clobbers('jsbridge/pay_checkoutPlatform', jsName + '.pay_checkoutPlatform');
//                      modulemapper.clobbers('jsbridge/pay_startWechatPay', jsName + '.pay_startWechatPay');
//                      modulemapper.clobbers('jsbridge/pay_startAliPay', jsName + '.pay_startAliPay');
               
                      modulemapper.clobbers('jsbridge/jd_openAppWebViewPage', jsName + '.jd_openAppWebViewPage');

                      modulemapper.clobbers('jsbridge/loginSuccess', jsName + '.base_loginSuccess');
                      modulemapper.clobbers('jsbridge/loginSuccess', jsName + '.base_logoutSuccess');
                      modulemapper.clobbers('jsbridge/loginSuccess', jsName + '.account_loginSuccess');
                      modulemapper.clobbers('jsbridge/logoutSuccess', jsName + '.account_logoutSuccess');
                      modulemapper.clobbers('jsbridge/account_appSocialSnsLogin', jsName + '.AppSocialSnsLogin');
                      modulemapper.clobbers('jsbridge/account_appSocialSnsLogin', jsName + '.appSocialSnsLogin');
                      modulemapper.clobbers('jsbridge/account_appSocialSnsLogin', jsName + '.account_appSocialSnsLogin');
                      modulemapper.clobbers('jsbridge/trackingIO_setProfile', jsName + '.trackingIO_setProfile');
                      modulemapper.clobbers('jsbridge/trackingIO_setEvent', jsName + '.trackingIO_setEvent');
                      modulemapper.clobbers('jsbridge/trackingIO_finishPay', jsName + '.trackingIO_finishPay');
                      modulemapper.clobbers('jsbridge/trackingIO_startPay', jsName + '.trackingIO_startPay');
                      modulemapper.clobbers('jsbridge/trackingIO_loginAccount', jsName + '.trackingIO_loginAccount');
                      modulemapper.clobbers('jsbridge/trackingIO_registerAccount', jsName + '.trackingIO_registerAccount');
                      modulemapper.clobbers('jsbridge/base_requestLocation', jsName + '.base_requestLocation');
                      modulemapper.clobbers('jsbridge/startNavigate', jsName + '.startNavigate');

                      modulemapper.clobbers('jsbridge/appTextResignFirstResponder', jsName + '.appTextResignFirstResponder');
                      modulemapper.clobbers('jsbridge/appTextResignFirstResponder', jsName + '.AppTextResignFirstResponder');
                      modulemapper.clobbers('jsbridge/userVisitorMode', jsName + '.userVisitorMode');
                      modulemapper.clobbers('jsbridge/userVisitorMode', jsName + '.UserVisitorMode');
                      modulemapper.clobbers('jsbridge/chat_switchInputToolStatus', jsName + '.chat_switchInputToolStatus');

                      modulemapper.clobbers('jsbridge/base_localStorageClean', jsName + '.base_localStorageClean');
                      modulemapper.clobbers('jsbridge/base_localStorageGetItem', jsName + '.base_localStorageGetItem');
                      modulemapper.clobbers('jsbridge/base_localStorageSetItem', jsName + '.base_localStorageSetItem');
                      modulemapper.clobbers('jsbridge/base_localStorageRemoveItem', jsName + '.base_localStorageRemoveItem');
                      modulemapper.clobbers('jsbridge/base_localStorageAllItems', jsName + '.base_localStorageAllItems');
                      modulemapper.clobbers('jsbridge/account_getInfo', jsName + '.account_getInfo');

                      modulemapper.clobbers('jsbridge/base_saveToAlbum', jsName + '.base_saveToAlbum');
                      modulemapper.clobbers('jsbridge/imageviewer', jsName + '.imageViewer');
                      modulemapper.clobbers('jsbridge/imageviewer', jsName + '.ImageViewer');
                      modulemapper.clobbers('jsbridge/imageviewer', jsName + '.imageviewer');

                      modulemapper.clobbers('jsbridge/base_rate', jsName + '.base_rate');

                      modulemapper.clobbers('jsbridge/base_SetStatusColor', jsName + '.base_SetStatusColor');
                      modulemapper.clobbers('jsbridge/base_SetStatusColor', jsName + '.base_setStatusColor');
               
                      modulemapper.clobbers('jsbridge/base_phoneIsExistApp', jsName + '.base_phoneIsExistApp');
                      modulemapper.clobbers('jsbridge/setNativeClipboard', jsName + '.base_setNativeClipboard');
                      modulemapper.clobbers('jsbridge/getNativeClipboard', jsName + '.base_getNativeClipboard');
                      modulemapper.clobbers('jsbridge/base_stopLoading', jsName + '.base_stopLoading');
                      modulemapper.clobbers('jsbridge/base_startLoading', jsName + '.base_startLoading');
                      modulemapper.clobbers('jsbridge/getSystemVersion', jsName + '.getSystemVersion');
                      modulemapper.clobbers('jsbridge/getAppVersion', jsName + '.getAppVersion');
                      modulemapper.clobbers('jsbridge/getPhoneModel', jsName + '.getPhoneModel');
                      modulemapper.clobbers('jsbridge/openGamePage', jsName + '.openGamePage');

                      modulemapper.clobbers('jsbridge/alibc_showWebPage', jsName + '.alibc_showWebPage');
                      modulemapper.clobbers('jsbridge/alibc_login', jsName + '.alibc_login');
                      modulemapper.clobbers('jsbridge/alibc_isLogin', jsName + '.alibc_isLogin');
                      ///声明


                      // Call the platform-specific initialization.
                      platform.bootstrap && platform.bootstrap();
                      setTimeout(function () {
                                    pluginloader.load(function () {
                                           channel.onPluginsReady.fire();
                                           window.cordova = cordova;
                                           window.zzcjsbridge = cordova;
                                           window.zzcjsbridge.jssdkver = "3.0.0";
                                           require('cordova').fireDocumentEvent('pluginsready');
                                    });
                             },
                             0);
                      channel.join(function () {
                                    modulemapper.mapModules(window);

                                    platform.initialize && platform.initialize();

                                    channel.onCordovaReady.fire();
                                    channel.join(function () {
                                                  require('cordova').fireDocumentEvent('deviceready');
                                           },
                                           channel.deviceReadyChannelsArray);

                             },
                             platformInitChannelsArray);
               });

        // file: src/common/init_b.js
        define("cordova/init_b",
               function (require, exports, module) {

                      var channel = require('cordova/channel');
                      var cordova = require('cordova');
                      var platform = require('cordova/platform');
                      var utils = require('cordova/utils');

                      var platformInitChannelsArray = [channel.onDOMContentLoaded, channel.onNativeReady];

                      // setting exec
                      cordova.exec = require('cordova/exec');

                      function logUnfiredChannels(arr) {
                             for (var i = 0; i < arr.length; ++i) {
                                    if (arr[i].state != 2) {
                                           console.log('Channel not fired: ' + arr[i].type);
                                    }
                             }
                      }

                      window.setTimeout(function () {
                                    if (channel.onDeviceReady.state != 2) {
                                           console.log('deviceready has not fired after 5 seconds.');
                                           logUnfiredChannels(platformInitChannelsArray);
                                           logUnfiredChannels(channel.deviceReadyChannelsArray);
                                    }
                             },
                             5000);

                      function replaceNavigator(origNavigator) {
                             var CordovaNavigator = function () {};
                             CordovaNavigator.prototype = origNavigator;
                             var newNavigator = new CordovaNavigator();
                             if (CordovaNavigator.bind) {
                                    for (var key in origNavigator) {
                                           if (typeof origNavigator[key] == 'function') {
                                                  newNavigator[key] = origNavigator[key].bind(origNavigator);
                                           } else {
                                                  (function (k) {
                                                         utils.defineGetterSetter(newNavigator, key,
                                                                function () {
                                                                       return origNavigator[k];
                                                                });
                                                  })(key);
                                           }
                                    }
                             }
                             return newNavigator;
                      }
                      if (window.navigator) {
                             window.navigator = replaceNavigator(window.navigator);
                      }

                      if (!window.console) {
                             window.console = {
                                    log: function () {}
                             };
                      }
                      if (!window.console.warn) {
                             window.console.warn = function (msg) {
                                    this.log("warn: " + msg);
                             };
                      }

                      // Register pause, resume and deviceready channels as events on document.
                      channel.onPause = cordova.addDocumentEventHandler('pause');
                      channel.onResume = cordova.addDocumentEventHandler('resume');
                      channel.onDeviceReady = cordova.addStickyDocumentEventHandler('deviceready');

                      // Listen for DOMContentLoaded and notify our channel subscribers.
                      if (document.readyState == 'complete' || document.readyState == 'interactive') {
                             channel.onDOMContentLoaded.fire();
                      } else {
                             document.addEventListener('DOMContentLoaded',
                                    function () {
                                           channel.onDOMContentLoaded.fire();
                                    },
                                    false);
                      }
                      if (window._nativeReady) {
                             channel.onNativeReady.fire();
                      }

                      // Call the platform-specific initialization.
                      platform.bootstrap && platform.bootstrap();
                      channel.join(function () {

                                    platform.initialize && platform.initialize();
                                    channel.onCordovaReady.fire();
                                    channel.join(function () {
                                                  require('cordova').fireDocumentEvent('deviceready');
                                           },
                                           channel.deviceReadyChannelsArray);

                             },
                             platformInitChannelsArray);

               });
        define("cordova/modulemapper",
               function (require, exports, module) {

                      var builder = require('cordova/builder'),
                             moduleMap = define.moduleMap,
                             symbolList,
                             deprecationMap;

                      exports.reset = function () {
                             symbolList = [];
                             deprecationMap = {};
                      };

                      function addEntry(strategy, moduleName, symbolPath, opt_deprecationMessage) {
                             if (!(moduleName in moduleMap)) {
                                    throw new Error('Module ' + moduleName + ' does not exist.');
                             }
                             symbolList.push(strategy, moduleName, symbolPath);
                             if (opt_deprecationMessage) {
                                    deprecationMap[symbolPath] = opt_deprecationMessage;
                             }
                      }

                      // Note: Android 2.3 does have Function.bind().
                      exports.clobbers = function (moduleName, symbolPath, opt_deprecationMessage) {
                             addEntry('c', moduleName, symbolPath, opt_deprecationMessage);
                      };

                      exports.merges = function (moduleName, symbolPath, opt_deprecationMessage) {
                             addEntry('m', moduleName, symbolPath, opt_deprecationMessage);
                      };

                      exports.defaults = function (moduleName, symbolPath, opt_deprecationMessage) {
                             addEntry('d', moduleName, symbolPath, opt_deprecationMessage);
                      };

                      exports.runs = function (moduleName) {
                             addEntry('r', moduleName, null);
                      };

                      function prepareNamespace(symbolPath, context) {
                             if (!symbolPath) {
                                    return context;
                             }
                             var parts = symbolPath.split('.');
                             var cur = context;
                             for (var i = 0,
                                           part; part = parts[i]; ++i) {
                                    cur = cur[part] = cur[part] || {};
                             }
                             return cur;
                      }

                      exports.mapModules = function (context) {
                             var origSymbols = {};
                             context.CDV_origSymbols = origSymbols;
                             for (var i = 0,
                                           len = symbolList.length; i < len; i += 3) {
                                    var strategy = symbolList[i];
                                    var moduleName = symbolList[i + 1];
                                    var module = require(moduleName);
                                    // <runs/>
                                    if (strategy == 'r') {
                                           continue;
                                    }
                                    var symbolPath = symbolList[i + 2];
                                    var lastDot = symbolPath.lastIndexOf('.');
                                    var namespace = symbolPath.substr(0, lastDot);
                                    var lastName = symbolPath.substr(lastDot + 1);

                                    var deprecationMsg = symbolPath in deprecationMap ? 'Access made to deprecated symbol: ' + symbolPath + '. ' + deprecationMsg : null;
                                    var parentObj = prepareNamespace(namespace, context);
                                    var target = parentObj[lastName];

                                    if (strategy == 'm' && target) {
                                           builder.recursiveMerge(target, module);
                                    } else if ((strategy == 'd' && !target) || (strategy != 'd')) {
                                           if (!(symbolPath in origSymbols)) {
                                                  origSymbols[symbolPath] = target;
                                           }
                                           builder.assignOrWrapInDeprecateGetter(parentObj, lastName, module, deprecationMsg);
                                    }
                             }
                      };

                      exports.getOriginalSymbol = function (context, symbolPath) {
                             var origSymbols = context.CDV_origSymbols;
                             if (origSymbols && (symbolPath in origSymbols)) {
                                    return origSymbols[symbolPath];
                             }
                             var parts = symbolPath.split('.');
                             var obj = context;
                             for (var i = 0; i < parts.length; ++i) {
                                    obj = obj && obj[parts[i]];
                             }
                             return obj;
                      };

                      exports.reset();

               });

        // file: src/ios/platform.js
        define("cordova/platform",
               function (require, exports, module) {

                      module.exports = {
                             id: 'ios',
                             bootstrap: function () {
                                    require('cordova/channel').onNativeReady.fire();
                             }
                      };

               });

        define("cordova/plugin_list",
               function (require, exports, module) {
                      module.exports = [];
                      module.exports.metadata = {}
               });
        define("cordova/pluginloader",
               function (require, exports, module) {

                      var modulemapper = require('cordova/modulemapper');
                      var urlutil = require('cordova/urlutil');

                      require('cordova/plugin_list');
                      exports.injectScript = function (url, onload, onerror) {
                             var script = document.createElement("script");
                             script.onload = onload;
                             script.onerror = onerror;
                             document.head.appendChild(script);
                      };

                      function injectIfNecessary(id, url, onload, onerror) {
                             onerror = onerror || onload;
                             if (id in define.moduleMap) {
                                    onload();
                             } else {
                                    exports.injectScript(url,
                                           function () {
                                                  if (id in define.moduleMap) {
                                                         onload();
                                                  } else {
                                                         onerror();
                                                  }
                                           },
                                           onerror);
                             }
                      }

                      function onScriptLoadingComplete(moduleList, finishPluginLoading) {
                             for (var i = 0,
                                           module; module = moduleList[i]; i++) {
                                    if (module.clobbers && module.clobbers.length) {
                                           for (var j = 0; j < module.clobbers.length; j++) {
                                                  modulemapper.clobbers(module.id, module.clobbers[j]);
                                           }
                                    }

                                    if (module.merges && module.merges.length) {
                                           for (var k = 0; k < module.merges.length; k++) {
                                                  modulemapper.merges(module.id, module.merges[k]);
                                           }
                                    }

                                    // Finally, if runs is truthy we want to simply require() the module.
                                    if (module.runs) {
                                           modulemapper.runs(module.id);
                                    }
                             }

                             finishPluginLoading();
                      }

                      function handlePluginsObject(path, moduleList, finishPluginLoading) {
                             // Now inject the scripts.
                             var scriptCounter = moduleList.length;

                             if (!scriptCounter) {
                                    finishPluginLoading();
                                    return;
                             }

                             function scriptLoadedCallback() {
                                    if (!--scriptCounter) {
                                           onScriptLoadingComplete(moduleList, finishPluginLoading);
                                    }
                             }

                             for (var i = 0; i < moduleList.length; i++) {
                                    injectIfNecessary(moduleList[i].id, path + moduleList[i].file, scriptLoadedCallback);
                             }
                      }

                      function findCordovaPath() {
                             var path = null;
                             var scripts = document.getElementsByTagName('script');
                             var term = '/cordova.js';
                             for (var n = scripts.length - 1; n > -1; n--) {
                                    var src = scripts[n].src.replace(/\?.*$/, ''); // Strip any query param (CB-6007).
                                    if (src.indexOf(term) == (src.length - term.length)) {
                                           path = src.substring(0, src.length - term.length) + '/';
                                           break;
                                    }
                             }
                             // return path;
                             return '';
                      }
                      exports.load = function (callback) {
                             var pathPrefix = findCordovaPath();
                             if (pathPrefix === null) {
                                    console.log('Could not find cordova.js script tag. Plugin loading may fail.');
                                    pathPrefix = '';
                             }
                             callback();
                      };

               });

        define("cordova/urlutil",
               function (require, exports, module) {
                      exports.makeAbsolute = function makeAbsolute(url) {
                             var anchorEl = document.createElement('a');
                             anchorEl.href = url;
                             return anchorEl.href;
                      };

               });
        define("cordova/utils",
               function (require, exports, module) {

                      var utils = exports;
                      utils.defineGetterSetter = function (obj, key, getFunc, opt_setFunc) {
                             if (Object.defineProperty) {
                                    var desc = {
                                           get: getFunc,
                                           configurable: true
                                    };
                                    if (opt_setFunc) {
                                           desc.set = opt_setFunc;
                                    }
                                    Object.defineProperty(obj, key, desc);
                             } else {
                                    obj.__defineGetter__(key, getFunc);
                                    if (opt_setFunc) {
                                           obj.__defineSetter__(key, opt_setFunc);
                                    }
                             }
                      };
                      utils.defineGetter = utils.defineGetterSetter;

                      utils.arrayIndexOf = function (a, item) {
                             if (a.indexOf) {
                                    return a.indexOf(item);
                             }
                             var len = a.length;
                             for (var i = 0; i < len; ++i) {
                                    if (a[i] == item) {
                                           return i;
                                    }
                             }
                             return -1;
                      };
                      utils.arrayRemove = function (a, item) {
                             var index = utils.arrayIndexOf(a, item);
                             if (index != -1) {
                                    a.splice(index, 1);
                             }
                             return index != -1;
                      };

                      utils.typeName = function (val) {
                             return Object.prototype.toString.call(val).slice(8, -1);
                      };
                      utils.isArray = function (a) {
                             return utils.typeName(a) == 'Array';
                      };
                      utils.isDate = function (d) {
                             return utils.typeName(d) == 'Date';
                      };
                      utils.clone = function (obj) {
                             if (!obj || typeof obj == 'function' || utils.isDate(obj) || typeof obj != 'object') {
                                    return obj;
                             }

                             var retVal, i;

                             if (utils.isArray(obj)) {
                                    retVal = [];
                                    for (i = 0; i < obj.length; ++i) {
                                           retVal.push(utils.clone(obj[i]));
                                    }
                                    return retVal;
                             }

                             retVal = {};
                             for (i in obj) {
                                    if (!(i in retVal) || retVal[i] != obj[i]) {
                                           retVal[i] = utils.clone(obj[i]);
                                    }
                             }
                             return retVal;
                      };
                      utils.close = function (context, func, params) {
                             if (typeof params == 'undefined') {
                                    return function () {
                                           return func.apply(context, arguments);
                                    };
                             } else {
                                    return function () {
                                           return func.apply(context, params);
                                    };
                             }
                      };
                      utils.createUUID = function () {
                             return UUIDcreatePart(4) + '-' + UUIDcreatePart(2) + '-' + UUIDcreatePart(2) + '-' + UUIDcreatePart(2) + '-' + UUIDcreatePart(6);
                      };
                      utils.extend = (function () {
                             // proxy used to establish prototype chain
                             var F = function () {};
                             // extend Child from Parent
                             return function (Child, Parent) {
                                    F.prototype = Parent.prototype;
                                    Child.prototype = new F();
                                    Child.__super__ = Parent.prototype;
                                    Child.prototype.constructor = Child;
                             };
                      }());
                      utils.alert = function (msg) {
                             if (window.alert) {
                                    window.alert(msg);
                             } else if (console && console.log) {
                                    console.log(msg);
                             }
                      };

                      function UUIDcreatePart(length) {
                             var uuidpart = "";
                             for (var i = 0; i < length; i++) {
                                    var uuidchar = parseInt((Math.random() * 256), 10).toString(16);
                                    if (uuidchar.length == 1) {
                                           uuidchar = "0" + uuidchar;
                                    }
                                    uuidpart += uuidchar;
                             }
                             return uuidpart;
                      }

               });

        //TODO: 方法实现
        define("jsbridge/base_backToPreviousPage",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var step = jsParameter.step;
                             var jsContent = jsParameter.jsContent;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'NativePageJump', 'goToBackPage', [step, jsContent]);
                      }
               });
        define("jsbridge/base_goBackPage",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var step = jsParameter.step;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'NativePageJump', 'goBackPage', [step]);
                      }
               });
        define("jsbridge/jumpToTopPage",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var tab = jsParameter.tabIndex;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'NativePageJump', 'jumpToTopPage', [tab]);
                      }
               });
        define("jsbridge/base_destroyPage",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var urls = jsParameter.urls;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'NativePageJump', 'destroyPage', [urls]);
                      }
               });
        define("jsbridge/controlLeftPanGesture",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var off = jsParameter.off;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'NativePageJump', 'controlLeftPanGesture', [off]);
                      }
               });
        define("jsbridge/showNavBarMoreMenu",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var customItems = jsParameter.customItems;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ZZCAlertTools', 'showNavBarMoreMenu', [customItems]);
                      }
               });
        define("jsbridge/share",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var title = jsParameter.title;
                             var content = jsParameter.content;
                             var photo = jsParameter.photo;
                             var url = jsParameter.shareUrl;
                             var platforms = jsParameter.sharePlatform;
                             if (!platforms) {
                                    platforms = jsParameter.sharePlatforms;
                             }
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ZZCAlertTools', 'showShareAlert', [title, content, photo, url, platforms]);
                      }
               });
        define("jsbridge/showActionSheet",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var options = jsParameter.options;
                             var cancelButtonIndex = jsParameter.cancelButtonIndex;
                             var destructiveButtonIndex = jsParameter.destructiveButtonIndex;
                             var title = jsParameter.title;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "ZZCAlertTools", "showActionSheet", [options, cancelButtonIndex, destructiveButtonIndex, title]);
                      }
               });
        define("jsbridge/setTopNavBarFadeIn",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var startOffset = jsParameter.startOffset;
                             var endOffset = jsParameter.endOffset;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ZZCNavigationBar', 'setTopNavBarFadeIn', [startOffset, endOffset]);
                      }
               });
        define("jsbridge/navBarRightButtons",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var navList = jsParameter.items;
                             var topList = jsParameter.topItems;
                             var onClick = 'app:navbarRightButtonsClick';
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ZZCNavigationBar', 'navBarRightButtons', [navList, topList, onClick]);
                      }
               });
        define("jsbridge/navBarLeftButtons",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var navList = jsParameter.items;
                             var topList = jsParameter.topItems;
                             var onClick = 'app:navbarLeftButtonClick';
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ZZCNavigationBar', 'navBarLeftButtons', [navList, topList, onClick]);
                      }
               });
        define("jsbridge/customNavbarRightButton",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {

                             var type = jsParameter.type;
                             var text = jsParameter.text;
                             var imageUrl = jsParameter.imageUrl;
                             var onClick = jsParameter.onClick;
                             var textColor = jsParameter.textColor;
                             var imageW = jsParameter.imageW;
                             var imageH = jsParameter.imageH;
                             var topImageUrl = jsParameter.topImageUrl;
                             if (onClick == null) {
                                    onClick = 'barRightButton-click';
                             }
                             var resultCallback = jsParameter.success;

                             var navList = [{
                                    'icon': imageUrl,
                                    'text': text,
                                    'type': type,
                                    'textColor': textColor,
                                    'imageW': imageW,
                                    'imageH': imageH
                             }];
                             var topList = [{
                                    'icon': topImageUrl,
                                    'type': type
                             }];
                             exec(resultCallback, null, 'ZZCNavigationBar', 'navBarRightButtons', [navList, topList, onClick]);
                      }
               });
        define("jsbridge/customNavbarLeftButton",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var type = jsParameter.type;
                             var text = jsParameter.text;
                             var imageUrl = jsParameter.imageUrl;
                             var topImageUrl = jsParameter.topImageUrl;
                             var textColor = jsParameter.textColor;
                             var imageW = jsParameter.imageW;
                             var imageH = jsParameter.imageH;
                             var onClick = jsParameter.onClick;
                             if (onClick == null) {
                                    onClick = 'app:navbarLeftButtonClick';
                             }
                             var resultCallback = jsParameter.success;

                             var navList = [{
                                    'icon': imageUrl,
                                    'text': text,
                                    'type': type,
                                    'textColor': textColor,
                                    'imageW': imageW,
                                    'imageH': imageH
                             }];
                             var topList = [{
                                    'icon': topImageUrl,
                                    'type': type
                             }];
                             exec(resultCallback, null, 'ZZCNavigationBar', 'navBarLeftButtons', [navList, topList, onClick]);
                      }
               });
        define("jsbridge/setTopBackBtnState",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var state = jsParameter.state;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ZZCNavigationBar', 'setTopBackBtnState', [state]);
                      }
               });
        define("jsbridge/setTitle",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var type = jsParameter.type;
                             var title = jsParameter.title;
                             var color = jsParameter.color;
                             var isReflected = jsParameter.isReflected;
                             if (isReflected && !type) {
                                    type = "button";
                             }
                             var onClick = jsParameter.onClick;
                             if (!onClick) {
                                    if (jsParameter.webViewUrl) {
                                           onClick = jsParameter.webViewUrl;
                                    } else {
                                           onClick = "app:clickNavbarTitle"
                                    }
                             }
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ZZCNavigationBar', 'setTitle', [type, title, color, onClick]);
                      }
               });

//        define("jsbridge/startAlipay",
//               function (require, exports, module) {
//                      var exec = require("cordova/exec");
//                      module.exports = function (jsParameter) {
//                             var orderID = jsParameter.orderID;
//                             var orderChannel = jsParameter.orderChannel;
//                             var payID = jsParameter.payID;
//                             if (!orderChannel) {
//                                    orderChannel = "w_deposit_wap";
//                             }
//                             var resultCallback = jsParameter.success;
//                             exec(resultCallback, null, 'ZZCAppMoneyPay', 'alipay', [orderID, orderChannel, payID]);
//                      }
//               });

        define("jsbridge/nativePay",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var channel = jsParameter.channel;
                             var type = jsParameter.type;
                             var data = jsParameter.data;
                             var url = jsParameter.url;
                             if (!channel) {
                                    channel = "w_deposit_wap";
                             }
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'LZAppMoneyPay', 'nativePay', [channel, type, data, url]);
                      }
               });
  
        define("jsbridge/alipayAppIsInstalled",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ZZCAppMoneyPay', 'alipayappcheck', []);
                      }
               });
//        define("jsbridge/startWechatPay",
//               function (require, exports, module) {
//                      var exec = require("cordova/exec");
//                      module.exports = function (jsParameter) {
//                             var orderID = jsParameter.orderID;
//                             var orderChannel = jsParameter.orderChannel;
//                             var payID = jsParameter.payID;
//                             if (!orderChannel) {
//                                    orderChannel = "w_deposit_wap";
//                             }
//                             var resultCallback = jsParameter.success;
//                             exec(resultCallback, null, "ZZCAppMoneyPay", "wxpay", [orderID, orderChannel, payID]);
//                      }
//               });
        define("jsbridge/wechatAppIsInstalled",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ZZCAppMoneyPay', 'wxpayappcheck', []);
                      }
               });
        define("jsbridge/verifyPayType",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var clientType = jsParameter.clientType;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "ZZCAppMoneyPay", "verifyPayType", [clientType]);
                      }
               });
        define("jsbridge/com_checkPayClient",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var clientType = jsParameter.clientType;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "ZZCAppMoneyPay", "com_checkPayClient", [clientType]);
                      }
               });
        define("jsbridge/pay_checkoutPlatform",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var platforms = jsParameter.platforms;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "ZZCAppMoneyPay", "checkoutPlatform", [platforms]);
                      }
               });
        define("jsbridge/jd_openAppWebViewPage",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var url = jsParameter.url;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "JDOpenPlugin", "openUrl", [url]);
                    }
               });
        define("jsbridge/openGamePage",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "VCGamePlugin", "openGamePage", []);
                    }
             });
  
  
//        define("jsbridge/pay_startWechatPay",
//               function (require, exports, module) {
//                      var exec = require("cordova/exec");
//                      module.exports = function (jsParameter) {
//                             var orderSN = jsParameter.orderSN;
//                             var channel = jsParameter.channel;
//                             var payID = jsParameter.payId;
//                             if (!channel) {
//                                    channel = "w_deposit_wap";
//                             }
//                             var resultCallback = jsParameter.success;
//                             exec(resultCallback, null, "ZZCAppMoneyPay", "startWechatPay", [orderSN, channel, payID]);
//                      }
//               });
//
//        define("jsbridge/pay_startAliPay",
//               function (require, exports, module) {
//                      var exec = require("cordova/exec");
//                      module.exports = function (jsParameter) {
//                             var orderSN = jsParameter.orderSN;
//                             var channel = jsParameter.channel;
//                             var payID = jsParameter.payId;
//                             if (!channel) {
//                                    channel = "w_deposit_wap";
//                             }
//                             var resultCallback = jsParameter.success;
//                             exec(resultCallback, null, "ZZCAppMoneyPay", "startAliPay", [orderSN, channel, payID]);
//                      }
//               });
        define("jsbridge/loginSuccess",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var userID = jsParameter.userID;
                             var token = jsParameter.token;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'UserService', 'loginSuccess', [userID, token]);
                      }
               });
        define("jsbridge/logoutSuccess",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'UserService', 'logoutSuccess', []);
                      }
               });
        define("jsbridge/account_appSocialSnsLogin",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var platform = jsParameter.platform;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'UserService', 'appSocialSnsLogin', [platform]);
                      }
               });
        define("jsbridge/trackingIO_registerAccount",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var account = jsParameter.account;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "CPTrackingIO", "registerAccount", [account]);
                      }
               });
        define("jsbridge/trackingIO_loginAccount",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var account = jsParameter.account;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "CPTrackingIO", "loginAccount", [account]);
                      }
               });

        define("jsbridge/trackingIO_startPay",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var transactionId = jsParameter.transactionId;
                             var paymentType = jsParameter.paymentType;
                             var currencyType = jsParameter.currencyType;
                             var currencyAmount = jsParameter.currencyAmount;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "CPTrackingIO", "startPay", [transactionId, paymentType, currencyType, currencyAmount]);
                      }
               });

        define("jsbridge/trackingIO_finishPay",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var transactionId = jsParameter.transactionId;
                             var paymentType = jsParameter.paymentType;
                             var currencyType = jsParameter.currencyType;
                             var currencyAmount = jsParameter.currencyAmount;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "CPTrackingIO", "finishPay", [transactionId, paymentType, currencyType, currencyAmount]);
                      }
               });

        define("jsbridge/trackingIO_setEvent",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var eventName = jsParameter.eventName;
                             var extra = jsParameter.extra;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "CPTrackingIO", "setEvent", [eventName, extra]);
                      }
               });

        define("jsbridge/trackingIO_setProfile",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var extra = jsParameter.extra;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "CPTrackingIO", "setProfile", [extra]);
                      }
               });

        define("jsbridge/base_requestLocation",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var tips = jsParameter.tips;
                             var effect = jsParameter.effect;

                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "VCRequestLocationPlugin", "requestLocation", [tips, effect])
                      }
               });

        define("jsbridge/startNavigate",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var startPlace = jsParameter.startPlace;
                             var endPlace = jsParameter.endPlace;
                             var startLng = jsParameter.startLng;
                             var startLat = jsParameter.startLat;
                             var endLng = jsParameter.endLng;
                             var endLat = jsParameter.endLat;
                             var aMapGps = jsParameter.aMapGps;
                             var baiduGps = jsParameter.baiduGps;

                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "VCPilotPlugin", "startNavigate", [startPlace, endPlace, startLng, startLat, endLng, endLat, aMapGps, baiduGps])
                      }
               });

        define("jsbridge/appTextResignFirstResponder",
               function (require, exports, module) {
                      var exec = require('cordova/exec');
                      module.exports = function (jsParameter) {
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ChatPlugin', 'appTextResignFirstResponder', []);
                      };
               });

        define("jsbridge/userVisitorMode",
               function (require, exports, module) {
                      var exec = require('cordova/exec');
                      module.exports = function (jsParameter) {
                             var speech_mode = jsParameter.speech_mode;
                             var speech_send_type = jsParameter.speech_send_type;
                             var first_input_status = jsParameter.first_input_status;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ChatPlugin', 'appUserVisitorMode', [speech_mode, speech_send_type, first_input_status]);
                      };
               });

        define("jsbridge/chat_switchInputToolStatus",
               function (require, exports, module) {
                      var exec = require('cordova/exec');
                      module.exports = function (jsParameter) {
                             var input_status = jsParameter.input_status;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'ChatPlugin', 'switchInputToolStatus', [input_status]);
                      };
               });

        define("jsbridge/base_localStorageSetItem",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var key = jsParameter.key;
                             var value = jsParameter.value;
                             var namespace = jsParameter.namespace;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "LocalStorage", "setItem", [key, value, namespace])
                      }
               });

        define("jsbridge/base_localStorageGetItem",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var key = jsParameter.key;
                             var namespace = jsParameter.namespace;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "LocalStorage", "getItem", [key, namespace])
                      }
               });

        define("jsbridge/base_localStorageClean",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var namespace = jsParameter.namespace;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "LocalStorage", "clear", [namespace])
                      }
               });
        define("jsbridge/base_localStorageRemoveItem",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var key = jsParameter.key;
                             var namespace = jsParameter.namespace;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "LocalStorage", "removeItem", [key, namespace])
                      }
               });
        define("jsbridge/base_localStorageAllItems",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var namespace = jsParameter.namespace;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "LocalStorage", "allItems", [namespace])
                      }
               });
        define("jsbridge/account_getInfo",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var namespace = jsParameter.namespace;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "UserService", "userInfo", [])
                      }
               });

        define("jsbridge/imageviewer",
               function (require, exports, module) {
                      var exec = require('cordova/exec');
                      module.exports = function (jsParameter) {
                             var title = jsParameter.title;
                             var photos = jsParameter.photos;
                             var showIndex = jsParameter.showIndex;
                             var sourceType = jsParameter.sourceType;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, 'AppNativeImageViewer', 'imageviewer', [title, photos, showIndex, sourceType]);
                      };
               });

        define("jsbridge/base_saveToAlbum",
               function (require, exports, module) {
                      // body...
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             // body...
                             var successCallback = jsParameter.success;
                             var imageUrl = jsParameter.imageUrl;
                             var type = jsParameter.type;
                             var base64Str = jsParameter.base64Str;
                             exec(successCallback, null, "AppNativeImageViewer", "saveImageToAlbum", [type, imageUrl, base64Str]);
                      }
               });

        define("jsbridge/base_rate",
               function (require, exports, module) {
                      // body...
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             // body...
                             var successCallback = jsParameter.success;
                             exec(successCallback, null, "ERCRatePlugin", "base_rate", []);
                      }
               });

        define("jsbridge/base_SetStatusColor",
               function (require, exports, module) {
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             var statusColor = jsParameter.statusColor;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "SetStatusColor", "base_SetStatusColor", [statusColor])
                      }
               });

        define("jsbridge/base_phoneIsExistApp",
               function (require, exports, module) {
                      var exec = require('cordova/exec');
                      module.exports = function (jsParameter) {
                             var appName = jsParameter.appName;
                             var appNames = jsParameter.appNames;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "DevicePlugin", "phoneIsExistApp", [appName, appNames]);
                      };
               });

        define("jsbridge/setNativeClipboard",
               function (require, exports, module) {
                      var exec = require('cordova/exec');
                      module.exports = function (jsParameter) {
                             var content = jsParameter.content;
                             var alertContent = jsParameter.alertContent;
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "AppSetNativeClipboard", "setNativeClipboard", [content, alertContent]);
                      };
               });

        define("jsbridge/getNativeClipboard",
               function (require, exports, module) {
                      var exec = require('cordova/exec');
                      module.exports = function (jsParameter) {
                             var resultCallback = jsParameter.success;
                             exec(resultCallback, null, "AppSetNativeClipboard", "getNativeClipboard", []);
                      };
               });

        define("jsbridge/base_stopLoading",
               function (require, exports, module) {
                      // body...
                      var exec = require("cordova/exec");
                      module.exports = function (jsParameter) {
                             // body...
                             var successCallback = jsParameter.success;
                             exec(successCallback, null, "LoadingStatusControl", "stopLoadingStatus", []);
                      }
                     });

       define("jsbridge/base_startLoading",
              function (require, exports, module) {
                     // body...
                     var exec = require("cordova/exec");
                     module.exports = function (jsParameter) {
                            // body...
                            var successCallback = jsParameter.success;
                            exec(successCallback, null, "LoadingStatusControl", "startLoadingStatus", []);
                     }
              });

       define("jsbridge/getSystemVersion",
              function (require, exports, module) {
                     var exec = require("cordova/exec");
                     module.exports = function (jsParameter) {

                            var resultCallback = jsParameter.success;
                            exec(resultCallback, null, "DevicePlugin", "getSystemVersion", [])
                     }
              });

       define("jsbridge/getAppVersion",
              function (require, exports, module) {
                     var exec = require("cordova/exec");
                     module.exports = function (jsParameter) {

                            var resultCallback = jsParameter.success;
                            exec(resultCallback, null, "DevicePlugin", "getAppVersion", [])
                     }
              });

       define("jsbridge/getPhoneModel",
              function (require, exports, module) {
                     var exec = require("cordova/exec");
                     module.exports = function (jsParameter) {

                            var resultCallback = jsParameter.success;
                            exec(resultCallback, null, "DevicePlugin", "getPhoneModel", [])
                     }
              });

       define("jsbridge/alibc_isLogin",
              function (require, exports, module) {
                     var exec = require("cordova/exec");
                     module.exports = function (jsParameter) {
                            var resultCallback = jsParameter.success;
                            exec(resultCallback, null, 'AlibcPlugin', 'isAlibcLogin', []);
                     }
              });

       define("jsbridge/alibc_showWebPage",
              function (require, exports, module) {
                     var exec = require("cordova/exec");
                     module.exports = function (jsParameter) {
                            var itemId = jsParameter.itemId;
                            var pageType = jsParameter.pageType;
                            var pid = jsParameter.pid;
                            var resultCallback = jsParameter.success;
                            exec(resultCallback, null, 'AlibcPlugin', 'showWebPage', [itemId, pageType, pid]);
                     }
              });

       define("jsbridge/alibc_login",
              function (require, exports, module) {
                     var exec = require("cordova/exec");
                     module.exports = function (jsParameter) {
                            var resultCallback = jsParameter.success;
                            exec(resultCallback, null, 'AlibcPlugin', 'alibcLogin', []);
                     }
              });

        require('cordova/init');

 })();
